home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / valarray.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  25.5 KB  |  917 lines
  1. #ifndef __RW_VALARRAY__
  2. #define __RW_VALARRAY__
  3. #pragma option push -b -a4 -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * valaray - Declarations for the Standard Library valarray
  8.  *
  9.  * $Id: valarray,v 1.22 1996/09/25 00:46:13 philippe Exp $
  10.  *
  11.  ***************************************************************************
  12.  *
  13.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  14.  * ALL RIGHTS RESERVED *
  15.  * The software and information contained herein are proprietary to, and
  16.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  17.  * intends to preserve as trade secrets such software and information.
  18.  * This software is furnished pursuant to a written license agreement and
  19.  * may be used, copied, transmitted, and stored only in accordance with
  20.  * the terms of such license and with the inclusion of the above copyright
  21.  * notice.  This software and information or any other copies thereof may
  22.  * not be provided or otherwise made available to any other person.
  23.  *
  24.  * Notwithstanding any other lease or license that may pertain to, or
  25.  * accompany the delivery of, this computer software and information, the
  26.  * rights of the Government regarding its use, reproduction and disclosure
  27.  * are as set forth in Section 52.227-19 of the FARS Computer
  28.  * Software-Restricted Rights clause.
  29.  * 
  30.  * Use, duplication, or disclosure by the Government is subject to
  31.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  32.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  33.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  34.  * P.O. Box 2328, Corvallis, Oregon 97339.
  35.  *
  36.  * This computer software and information is distributed with "restricted
  37.  * rights."  Use, duplication or disclosure is subject to restrictions as
  38.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  39.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  40.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  41.  * then the "Alternate III" clause applies.
  42.  *
  43.  **************************************************************************/
  44.  
  45. #include <rw/valimp>
  46.  
  47. #ifndef _RWSTD_NO_NAMESPACE
  48. namespace std {
  49. #endif
  50.  
  51. // forward declarations
  52. class slice;
  53. template <class T> class  slice_array;
  54. class gslice;
  55. template <class T> class gslice_array;
  56. template <class T> class mask_array;
  57. template <class T> class indirect_array;
  58.  
  59.  
  60. /*************************************************************
  61.  *                     CLASS VALARRAY                        *
  62.  *************************************************************/
  63.  
  64. template <class T> class valarray {
  65.  
  66. public:
  67.  
  68.     typedef T value_type;
  69.  
  70. // constructors
  71.  
  72.     valarray( ) {;}
  73.  
  74.     _EXPLICIT valarray(size_t size)
  75.     { memory_array._initial_size(size); }
  76.  
  77.     valarray(const T& value, size_t size)
  78.     { memory_array._initialize_with_value(value,size); }
  79.  
  80.     valarray(const T* pointer, size_t size)
  81.     { memory_array._initialize_with_array(pointer,size); }
  82.  
  83.     valarray(const valarray<T>& array)
  84.     { memory_array._copy_memory_array(array._RW_get_memory_array()); }
  85.  
  86.     valarray(const slice_array<T>&);
  87.     valarray(const gslice_array<T>&);
  88.     valarray(const mask_array<T>&);
  89.     valarray(const indirect_array<T>&);
  90.  
  91.     // destructor
  92.  
  93.     ~valarray() {;}
  94.  
  95.     // operator =
  96.  
  97.     valarray<T>& operator= (const valarray<T>& array)
  98.         {
  99.           if ( this != &array )
  100.        memory_array._copy_memory_array(array._RW_get_memory_array());
  101.       return *this;
  102.         }
  103.  
  104.    valarray<T>& operator= (const slice_array<T>&);
  105.    valarray<T>& operator= (const gslice_array<T>&);
  106.    valarray<T>& operator= (const mask_array<T>&);
  107.    valarray<T>& operator= (const indirect_array<T>&);
  108.    valarray<T>& operator= (const T&);
  109.  
  110.     // operator[]
  111.  
  112.     T operator[] (size_t ind) const
  113.     { return memory_array[ind];  }
  114.  
  115.     T& operator[] (size_t ind)
  116.     { return memory_array[ind]; }
  117.  
  118.     valarray<T> operator[](slice) const;
  119.         inline slice_array<T> operator[](slice);
  120.         valarray<T> operator[](const gslice&) const;
  121.     inline gslice_array<T> operator[](const gslice&);
  122. #ifndef _MSC_VER
  123.     valarray<T> operator[](const valarray<bool>&) const;
  124. #endif
  125.     inline mask_array<T> operator[](const valarray<bool>&);
  126.     valarray<T> operator[](const valarray<size_t>&) const;
  127.     inline indirect_array<T> operator[](const valarray<size_t>&);
  128.  
  129.     // unary operators
  130.  
  131.     valarray<T> operator+() const;
  132.     valarray<T> operator-() const;
  133.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  134.     valarray<T> operator~() const;
  135.     valarray<bool> operator!() const;
  136.    #endif
  137.  
  138.     // computed assignment
  139.  
  140.    valarray<T>& operator*= (const valarray<T>& array);
  141.    valarray<T>& operator/= (const valarray<T>& array);
  142.    valarray<T>& operator+= (const valarray<T>& array);
  143.    valarray<T>& operator-= (const valarray<T>& array);
  144.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  145.    valarray<T>& operator%= (const valarray<T>& array);
  146.    valarray<T>& operator^= (const valarray<T>& array);
  147.    valarray<T>& operator&= (const valarray<T>& array);
  148.    valarray<T>& operator|= (const valarray<T>& array);
  149.    valarray<T>& operator<<= (const valarray<T>& array);
  150.    valarray<T>& operator>>= (const valarray<T>& array);
  151.    #endif
  152.  
  153.  
  154.    valarray<T>& operator*= (const T& val);
  155.    valarray<T>& operator/= (const T& val);
  156.    valarray<T>& operator%= (const T& val);
  157.    valarray<T>& operator+= (const T& val);
  158.    valarray<T>& operator-= (const T& val);
  159.    valarray<T>& operator^= (const T& val);
  160.    valarray<T>& operator&= (const T& val);
  161.    valarray<T>& operator|= (const T& val);
  162.    valarray<T>& operator<<= (const T& val);
  163.    valarray<T>& operator>>= (const T& val);
  164.  
  165.  
  166.    // others
  167.  
  168.    size_t size() const { return memory_array._get_length(); }
  169.  
  170.    T sum() const;
  171.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  172.    T min() const;
  173.    T max() const;
  174.    #endif
  175.  
  176.    valarray<T> shift(int sh) const;
  177.    valarray<T> cshift(int sh) const;
  178.  
  179.    valarray<T> apply(T func(T)) const;
  180.    valarray<T> apply(T func(const T&)) const;
  181.  
  182.    void free()
  183.    { memory_array._RW_resize_without_copy(0); }
  184.  
  185.    void resize(size_t sz, const T& c= T() )
  186.    {
  187.      memory_array._RW_resize_without_copy(sz);
  188.      *this = c;
  189.    }
  190.  
  191.     // implementation specific
  192.  
  193.     const _RW_IMP_SPACE(_RW_array<T>)& _RW_get_memory_array( ) const
  194.     { return memory_array; }
  195.  
  196.     _RW_IMP_SPACE(_RW_array<T>)* _RW_get_memory_array_adr( )
  197.     { return &memory_array; }
  198.  
  199.     valarray(_RW_IMP_SPACE(_RW_temporary<T>)* tmp)
  200.     {
  201.       memory_array._replace(tmp->store_adr,tmp->length);
  202.       delete tmp;
  203.     }
  204.  
  205. private:
  206.  
  207.     _RW_IMP_SPACE(_RW_array<T>)  memory_array;
  208.  
  209. };
  210.  
  211. /*
  212.  *   VALARRAY INLINE MEMBER FUNCTIONS
  213.  */
  214.  
  215.  
  216.    template <class T>
  217.    inline valarray<T>& valarray<T>::operator=(const T& value)
  218.    {
  219.      memory_array._initialize_with_value(value, size());
  220.      return *this;
  221.    }
  222.  
  223. // operator[] for slice
  224.   
  225.    template <class T>
  226.    inline slice_array<T> valarray<T>::operator[](slice sl)
  227.    {
  228.       return slice_array<T>(&memory_array, sl);
  229.    }
  230.  
  231.    // operator[] for gslice
  232.  
  233.      
  234.    template <class T>
  235.    inline gslice_array<T> valarray<T>::operator[](const gslice& sl)
  236.    {
  237.       return gslice_array<T>(&memory_array, sl);
  238.    }
  239.  
  240.  
  241. // operator[] for valarray[valarray<bool>] used with mask_array
  242.  
  243.   
  244.    template <class T>
  245.    inline mask_array<T> valarray<T>::operator[](const valarray<bool>& array)
  246.    {
  247.       return mask_array<T>(&memory_array, array);
  248.    }
  249.  
  250.  
  251. // operator[] for valarray[valarray<size_t>] used with indirect_array
  252.  
  253.  
  254.    template <class T>
  255.    inline indirect_array<T> valarray<T>::operator[](const valarray<size_t>& array)
  256.    {
  257.       return indirect_array<T>(&memory_array, array);
  258.    }
  259.  
  260. /*
  261.  *
  262.  *   VALARRAY NON MEMBER FUNCTIONS
  263.  *
  264.  */
  265.  
  266.  // binary operators
  267.  
  268.  template<class T>
  269.  valarray<T> operator* (const valarray<T>& , const valarray<T>&  );
  270.  
  271.  template<class T>
  272.  valarray<T> operator/ (const valarray<T>& , const valarray<T>& );
  273.  
  274.  template<class T>
  275.  valarray<T> operator% (const valarray<T>&, const valarray<T>&);
  276.  
  277.  template<class T>
  278.  valarray<T> operator+ (const valarray<T>& , const valarray<T>& );
  279.  
  280.  template<class T>
  281.  valarray<T> operator- (const valarray<T>& , const valarray<T>& );
  282.   
  283.  template<class T>
  284.  valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
  285.  
  286.  template<class T>
  287.  valarray<T> operator& (const valarray<T>&, const valarray<T>&);
  288.  
  289.  template<class T>
  290.  valarray<T> operator| (const valarray<T>&, const valarray<T>&);
  291.  
  292.  template<class T>
  293.  valarray<T> operator<< (const valarray<T>&, const valarray<T>&);
  294.  
  295.  template<class T>
  296.  valarray<T> operator>> (const valarray<T>&, const valarray<T>&);
  297.  
  298.  template<class T>
  299.  valarray<bool> operator&& (const valarray<T>&, const valarray<T>&);
  300.  
  301.  template<class T>
  302.  valarray<bool> operator|| (const valarray<T>&, const valarray<T>&);
  303.  
  304. // with non array second param
  305.  
  306.  template<class T>
  307.  valarray<T> operator* (const valarray<T>& , const T& );
  308.  
  309.  template<class T>
  310.  valarray<T> operator/ (const valarray<T>& , const T& );
  311.  
  312.  template<class T>
  313.  valarray<T> operator% (const valarray<T>&, const T&);
  314.  
  315.  template<class T>
  316.  valarray<T> operator+ (const valarray<T>& , const T& );
  317.  
  318.  template<class T>
  319.  valarray<T> operator- (const valarray<T>& , const T& );
  320.   
  321.  template<class T>
  322.  valarray<T> operator^ (const valarray<T>&, const T&);
  323.  
  324.  template<class T>
  325.  valarray<T> operator& (const valarray<T>&, const T&);
  326.  
  327.  template<class T>
  328.  valarray<T> operator| (const valarray<T>&, const T&);
  329.  
  330.  template<class T>
  331.  valarray<T> operator<< (const valarray<T>&, const T&);
  332.  
  333.  template<class T>
  334.  valarray<T> operator>> (const valarray<T>&, const T&);
  335.  
  336.  template<class T>
  337.  valarray<T> operator&& (const valarray<T>&, const T&);
  338.  
  339.  template<class T>
  340.  valarray<T> operator|| (const valarray<T>&, const T&);
  341.  
  342.  
  343. // with non array first param
  344.  
  345.  template<class T>
  346.  valarray<T> operator* (const T& , const valarray<T>& ); 
  347.  
  348.  template<class T>
  349.  valarray<T> operator/ (const T& , const valarray<T>& );
  350.  
  351.  template<class T>
  352.  valarray<T> operator% (const T&, const valarray<T>&);
  353.  
  354.  template<class T>
  355.  valarray<T> operator+ (const T& , const valarray<T>& );
  356.  
  357.  template<class T>
  358.  valarray<T> operator- (const T& , const valarray<T>& );
  359.  
  360.  template<class T>
  361.  valarray<T> operator^ (const T&, const valarray<T>&);
  362.  
  363.  template<class T>
  364.  valarray<T> operator& (const T&, const valarray<T>&);
  365.  
  366.  template<class T>
  367.  valarray<T> operator| (const T&, const valarray<T>&);
  368.  
  369.  template<class T>
  370.  valarray<T> operator<< (const T&, const valarray<T>&);
  371.  
  372.  template<class T>
  373.  valarray<T> operator>> (const T&, const valarray<T>&);
  374.  
  375.  template<class T>
  376.  valarray<T> operator&& (const T&, const valarray<T>&);
  377.  
  378.  template<class T>
  379.  valarray<T> operator|| (const T&, const valarray<T>&);
  380.  
  381. // comparison operators
  382.  
  383.  template<class T>
  384.  valarray<bool> operator== (const valarray<T>& , const valarray<T>& );
  385.   
  386.  template<class T>
  387.  valarray<bool> operator!= (const valarray<T>& , const valarray<T>& );
  388.    
  389.  template<class T>
  390.  valarray<bool> operator< (const valarray<T>& , const valarray<T>& );
  391.  
  392.  template<class T>
  393.  valarray<bool> operator> (const valarray<T>& , const valarray<T>& );
  394.    
  395.  template<class T>
  396.  valarray<bool> operator<= (const valarray<T>& , const valarray<T>& ); 
  397.  
  398.  template<class T>
  399.  valarray<bool> operator>= (const valarray<T>& , const valarray<T>& );
  400.  
  401. // comparison operators, non valarray second param
  402.  
  403.  template<class T>
  404.  valarray<bool> operator== (const valarray<T>& , const T& );
  405.  
  406.  template<class T>
  407.  valarray<bool> operator!= (const valarray<T>& , const T& );
  408.  
  409.  template<class T>
  410.  valarray<bool> operator< (const valarray<T>& , const T& );
  411.  
  412.  template<class T>
  413.  valarray<bool> operator> (const valarray<T>& , const T& );
  414.  
  415.  template<class T>
  416.  valarray<bool> operator<= (const valarray<T>& , const T& );
  417.   
  418.  template<class T>
  419.  valarray<bool> operator>= (const valarray<T>& , const T& );
  420.  
  421. // comparison operators, non valarray first param
  422.  
  423.  template<class T>
  424.  valarray<bool> operator== (const T& , const valarray<T>& );
  425.  
  426.  template<class T>
  427.  valarray<bool> operator!= (const T& , const valarray<T>& );
  428.  
  429.  template<class T>
  430.  valarray<bool> operator< (const T& , const valarray<T>& );
  431.  
  432.  template<class T>
  433.  valarray<bool> operator> (const T& , const valarray<T>& );
  434.  
  435.  template<class T>
  436.  valarray<bool> operator<= (const T& , const valarray<T>& ); 
  437.   
  438.  template<class T>
  439.  valarray<bool> operator>= (const T& , const valarray<T>& );
  440.  
  441.    
  442. // transcendentals
  443.  
  444. #ifdef _RWSTD_NO_NEW_HEADER 
  445. #ifndef _RWSTD_NO_NAMESPACE
  446. // needed for expression like valarray< valarray<float> > 
  447.  
  448.    inline long double cos(long double var) { return ::cos(var); }
  449.    inline double cos(double var) { return ::cos(var); }
  450.    inline float cos(float var) { return (float)::cos(var); }
  451.  
  452.    inline long double cosh(long double var) { return ::cosh(var); }
  453.    inline double cosh(double var) { return ::cosh(var); }
  454.    inline float cosh(float var) { return (float)::cosh(var); }
  455.  
  456.    inline long double exp(long double var) { return ::exp(var); }
  457.    inline double exp(double var) { return ::exp(var); }
  458.    inline float exp(float var) { return (float)::exp(var); }
  459.  
  460.    inline long double log(long double var) { return ::log(var); }
  461.    inline double log(double var) { return ::log(var); }
  462.    inline float log(float var) { return (float)::log(var); }
  463.  
  464.    inline long double log10(long double var) { return ::log10(var); }
  465.    inline double log10(double var) { return ::log10(var); }
  466.    inline float log10(float var) { return (float)::log10(var); }
  467.  
  468.    inline long double pow(long double var1, long double var2) { return ::pow(var1,var2); }
  469.    inline double pow(double var1, double var2) { return ::pow(var1,var2); }
  470.    inline float pow(float var1,float var2) { return (float)::pow(var1,var2); }
  471.  
  472.    inline long double sin(long double var) { return ::sin(var); }
  473.    inline double sin(double var) { return ::sin(var); }
  474.    inline float sin(float var) { return (float)::sin(var); }
  475.  
  476.    inline long double sinh(long double var) { return ::sinh(var); }
  477.    inline double sinh(double var) { return ::sinh(var); }
  478.    inline float sinh(float var) { return (float)::sinh(var); }
  479.  
  480.    inline long double sqrt(long double var) { return ::sqrt(var); }
  481.    inline double sqrt(double var) { return ::sqrt(var); }
  482.    inline float sqrt(float var) { return (float)::sqrt(var); }
  483.  
  484.    inline long double tan(long double var) { return ::tan(var); }
  485.    inline double tan(double var) { return ::tan(var); }
  486.    inline float tan(float var) { return (float)::tan(var); }
  487.  
  488.    inline long double tanh(long double var) { return ::tanh(var); }
  489.    inline double tanh(double var) { return ::tanh(var); }
  490.    inline float tanh(float var) { return (float)::tanh(var); }
  491.  
  492.    inline long double acos(long double var) { return ::acos(var); }
  493.    inline double acos(double var) { return ::acos(var); }
  494.    inline float acos(float var) { return (float)::acos(var); }
  495.  
  496.    inline long double asin(long double var) { return ::asin(var); }
  497.    inline double asin(double var) { return ::asin(var); }
  498.    inline float asin(float var) { return (float)::asin(var); }
  499.  
  500.    inline long double atan(long double var) { return ::atan(var); }
  501.    inline double atan(double var) { return ::atan(var); }
  502.    inline float atan(float var) { return (float)::atan(var); }
  503.  
  504.    inline long double atan2(long double var1, long double var2) { return ::atan2(var1,var2); }
  505.    inline double atan2(double var1, double var2) { return ::atan2(var1,var2); }
  506.    inline float atan2(float var1,float var2) { return (float)::atan2(var1,var2); }
  507.  
  508.    inline long double abs(long double var) { return (var>0) ? var : -var; }
  509.    inline double abs(double var) { return (var>0) ? var : -var; }
  510.    inline float abs(float var) { return (var>0) ? var : -var; }
  511.    inline long abs(long var) { return (var>0) ? var : -var; }
  512. #ifndef __TURBOC__
  513.    inline int abs(int var) { return (var>0) ? var : -var; }
  514. #endif
  515.    inline short abs(short var) { return (var>0) ? var : -var; }
  516.  
  517.  #endif
  518. #endif
  519.  
  520.  template<class T>
  521.  valarray<T> abs(const valarray<T>& );
  522.  
  523.  template<class T>
  524.  valarray<T> acos(const valarray<T>& );
  525.  
  526.  template<class T>
  527.  valarray<T> asin(const valarray<T>& );
  528.  
  529.  template<class T>
  530.  valarray<T> atan(const valarray<T>& );
  531.  
  532.  template<class T>
  533.  valarray<T> cos(const valarray<T>& );
  534.  
  535.  template<class T>
  536.  valarray<T> cosh(const valarray<T>& );
  537.  
  538.  template<class T>
  539.  valarray<T> exp(const valarray<T>& );
  540.  
  541.  template<class T>
  542.  valarray<T> log(const valarray<T>& );
  543.  
  544.  template<class T>
  545.  valarray<T> log10(const valarray<T>& );
  546.  
  547.  template<class T>
  548.  valarray<T> sinh(const valarray<T>& );
  549.  
  550.  template<class T>
  551.  valarray<T> sin(const valarray<T>& );
  552.  
  553.  template<class T>
  554.  valarray<T> sqrt(const valarray<T>& );
  555.  
  556.  template<class T>
  557.  valarray<T> tan(const valarray<T>& );
  558.  
  559.  template<class T>
  560.  inline valarray<T> tanh(const valarray<T>& );
  561.  
  562.  template<class T>
  563.  valarray<T> atan2(const valarray<T>& , const valarray<T>& );
  564.  
  565.  template<class T>
  566.  valarray<T> atan2(const valarray<T>& , const T& );
  567.  
  568.  template<class T>
  569.  valarray<T> atan2(const T& , const valarray<T>& );
  570.  
  571.  template<class T>
  572.  valarray<T> pow(const valarray<T>& , const valarray<T>& );
  573.  
  574.  template<class T>
  575.  valarray<T> pow(const valarray<T>& , const T& );
  576.  
  577.  template<class T>
  578.  valarray<T> pow(const T& , const valarray<T>& );
  579.  
  580. // Global min and max template fonction
  581. // for compiler that try to instantiate all the member function
  582.  
  583. #ifdef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  584. template <class T> T max(const valarray<T>&);
  585. template <class T> T min(const valarray<T>&);
  586. #endif
  587.  
  588. /****************************************************************
  589.  *                SLICE AND SLICE_ARRAY                         *
  590.  ****************************************************************/
  591.  
  592.  class slice {
  593.  
  594.  public:
  595.  
  596.      slice()
  597.      : start_(0), length_(0), stride_(0)
  598.      {;}
  599.      slice(size_t start, size_t length, size_t stride)
  600.      : start_(start)
  601.      , length_(length)
  602.      , stride_(stride)
  603.      {;}
  604.  
  605.      slice(const slice& sl)
  606.      :start_(sl.start())
  607.      ,length_(sl.length())
  608.      ,stride_(sl.stride())
  609.      {;}
  610.  
  611.      size_t start() const { return start_; }
  612.      size_t length() const { return length_; }
  613.      size_t stride() const { return stride_; }
  614.  
  615.  private:
  616.  
  617.      size_t start_;
  618.      size_t length_;
  619.      size_t stride_;
  620.  
  621.  };
  622.  
  623.  template <class T> class slice_array {
  624.  
  625.  
  626.  public:
  627.  
  628.      typedef T value_type;
  629.  
  630.      slice_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const slice& a ) 
  631.      :ref_mem_array(pt)
  632.      ,slice_(a)
  633.      {;}
  634.  
  635.      slice_array(const slice_array<T>& sl)
  636.      :ref_mem_array(sl.get_ref_mem_array())
  637.      ,slice_(sl.get_slice())
  638.      {;}
  639.  
  640.      _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  641.      slice get_slice() const { return slice_; }
  642.  
  643.     // assignment
  644.  
  645.         void operator= (const valarray<T>& ) const;
  646.         void operator= (const T&) const;
  647.  
  648.     // computed assignment
  649.  
  650.    void operator*= (const valarray<T>& ) const;
  651.    void operator/= (const valarray<T>& ) const;
  652.    void operator+= (const valarray<T>& ) const;
  653.    void operator-= (const valarray<T>& ) const;
  654.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  655.    void operator%= (const valarray<T>& ) const;
  656.    void operator^= (const valarray<T>& ) const;
  657.    void operator&= (const valarray<T>& ) const;
  658.    void operator|= (const valarray<T>& ) const;
  659.    void operator<<= (const valarray<T>& ) const;
  660.    void operator>>= (const valarray<T>& ) const;
  661.    #endif
  662.  
  663.     ~slice_array() {;}
  664.  
  665.  private:
  666.  
  667.      slice_array();
  668.      slice_array<T>& operator= (const slice_array<T>&);
  669.  
  670.      _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  671.      slice slice_;
  672.     
  673.  };
  674.  
  675.  
  676. /****************************************************************
  677.  *                GSLICE AND GSLICE_ARRAY                       *
  678.  ****************************************************************/
  679.  
  680.  class gslice {
  681.  
  682.  public:
  683.  
  684.      gslice()
  685.      : start_(0)
  686.      , reset_(true)
  687.      {;}
  688.      
  689.  
  690.      gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d)
  691.      : start_(s)
  692.      , length_(l)
  693.          , stride_(d)
  694.      , reset_(true)
  695.      , r_length_((size_t)0,l.size())
  696.      {;}
  697.  
  698.          gslice(const gslice& sl) 
  699.      : start_(sl.start())
  700.      , length_(sl.length())
  701.          , stride_(sl.stride())
  702.      , reset_(true)
  703.      , r_length_((size_t)0,sl.length().size())
  704.      {;}
  705.  
  706.      ~gslice() {;}
  707.  
  708.          size_t start() const { return start_; }
  709.      valarray<size_t> length() const { return length_; }
  710.      valarray<size_t> stride() const { return stride_; }
  711.  
  712.      size_t next_ind();
  713.      inline size_t is_reseted() const { return reset_; }
  714.      size_t ind_max() const;
  715.      size_t ind_numb() const;
  716.  
  717.  private:
  718.  
  719.      size_t start_;
  720.      valarray<size_t> length_;
  721.      valarray<size_t> stride_;
  722.  
  723.      bool reset_;
  724.      valarray<size_t>  r_length_;
  725.  
  726.  };
  727.  
  728.  
  729. // class gslice_array
  730.  
  731. template <class T> class gslice_array {
  732.  
  733.  
  734.  public:
  735.  
  736.      typedef T value_type;
  737.  
  738.      gslice_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const gslice& a ) 
  739.      :ref_mem_array(pt)
  740.      ,slice_(a)
  741.      {;}
  742.  
  743.      gslice_array(const gslice_array<T>& sl)
  744.      :ref_mem_array(sl.get_ref_mem_array())
  745.      ,slice_(sl.get_slice())
  746.      {;}
  747.  
  748.      _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  749.      gslice get_slice() const { return slice_; }
  750.  
  751.     // assignment
  752.  
  753.         void operator= (const valarray<T>& ) const;
  754.         void operator= (const T&) const;
  755.  
  756.     // computed assignment
  757.  
  758.    void operator*= (const valarray<T>& ) const;
  759.    void operator/= (const valarray<T>& ) const;
  760.    void operator+= (const valarray<T>& ) const;
  761.    void operator-= (const valarray<T>& ) const;
  762.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  763.    void operator%= (const valarray<T>& ) const;
  764.    void operator^= (const valarray<T>& ) const;
  765.    void operator&= (const valarray<T>& ) const;         
  766.    void operator|= (const valarray<T>& ) const;         
  767.    void operator<<= (const valarray<T>& ) const;        
  768.    void operator>>= (const valarray<T>& ) const;
  769.    #endif
  770.  
  771.     ~gslice_array() {;}
  772.  
  773.  private:
  774.  
  775.      gslice_array();
  776.      gslice_array<T>& operator= (const gslice_array<T>&);
  777.  
  778.      _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  779.      gslice slice_;
  780.     
  781.  };
  782.  
  783.  
  784. /****************************************************************
  785.  *                         MASK_ARRAY                           *
  786.  ****************************************************************/
  787.  
  788.  
  789. // class mask_array
  790.  
  791. template <class T> class mask_array {
  792.  
  793.  
  794.  public:
  795.  
  796.      typedef T value_type;
  797.  
  798.      mask_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const valarray<bool>& a )
  799.      :ref_mem_array(pt)
  800.      ,array(a)
  801.      {;}
  802.  
  803.      mask_array(const mask_array<T>& sl)
  804.      :ref_mem_array(sl.get_ref_mem_array())
  805.      ,array(sl.get_array())
  806.      {;}
  807.  
  808.      _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  809.      valarray<bool> get_array() const { return array; }
  810.      valarray<bool>* get_array_pt() { return &array; }
  811.  
  812.     // assignment
  813.  
  814.        void operator= (const valarray<T>& ) const;
  815.        void operator= (const T&) const;
  816.  
  817.     // computed assignment
  818.  
  819.    void operator*= (const valarray<T>& ) const;
  820.    void operator/= (const valarray<T>& ) const;
  821.    void operator+= (const valarray<T>& ) const;
  822.    void operator-= (const valarray<T>& ) const;
  823.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  824.    void operator%= (const valarray<T>& ) const;
  825.    void operator^= (const valarray<T>& ) const;
  826.    void operator&= (const valarray<T>& ) const;
  827.    void operator|= (const valarray<T>& ) const;
  828.    void operator<<= (const valarray<T>& ) const;
  829.    void operator>>= (const valarray<T>& ) const;
  830.    #endif
  831.  
  832.     ~mask_array() {;}
  833.  
  834.  private:
  835.  
  836.      mask_array();
  837.      mask_array<T>& operator= (const mask_array<T>&); 
  838.  
  839.      _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  840.      valarray<bool> array;
  841.     
  842.  };
  843.  
  844.   
  845. /****************************************************************
  846.  *                       INDIRECT_ARRAY                         *
  847.  ****************************************************************/
  848.  
  849.  
  850. // class indirect_array
  851.  
  852. template <class T> class indirect_array {
  853.  
  854.  
  855.  public:
  856.  
  857.      typedef T value_type;
  858.  
  859.      indirect_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const valarray<size_t>& a ) 
  860.      :ref_mem_array(pt)
  861.      ,array(a)
  862.      {;}
  863.  
  864.      indirect_array(const indirect_array<T>& sl)
  865.      :ref_mem_array(sl.get_ref_mem_array())
  866.      ,array(sl.get_array())
  867.      {;}
  868.  
  869.          _RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
  870.      valarray<size_t> get_array() const { return array; }
  871.          valarray<size_t>* get_array_pt() { return &array; }
  872.  
  873.     // assignment
  874.  
  875.         void operator= (const valarray<T>& ) const;
  876.         void operator= (const T& ) const;
  877.  
  878.     // computed assignment
  879.  
  880.    void operator*= (const valarray<T>& ) const;
  881.    void operator/= (const valarray<T>& ) const;
  882.    void operator+= (const valarray<T>& ) const;
  883.    void operator-= (const valarray<T>& ) const;
  884.    #ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
  885.    void operator%= (const valarray<T>& ) const;
  886.    void operator^= (const valarray<T>& ) const;
  887.    void operator&= (const valarray<T>& ) const;
  888.    void operator|= (const valarray<T>& ) const;
  889.    void operator<<= (const valarray<T>& ) const;
  890.    void operator>>= (const valarray<T>& ) const;
  891.    #endif
  892.  
  893.     ~indirect_array() {;}
  894.  
  895.  private:
  896.  
  897.      indirect_array();
  898.      indirect_array<T>& operator= (const indirect_array<T>&); 
  899.  
  900.      _RW_IMP_SPACE(_RW_array<T>)*  ref_mem_array;
  901.      valarray<size_t> array;
  902.  
  903.  };
  904.  
  905. #ifndef _RWSTD_NO_NAMESPACE
  906. }
  907. #endif
  908.  
  909. #ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
  910. #include <valarray.cc>
  911. #endif
  912.  
  913. #pragma option pop
  914.  
  915. #endif /* __VALARRAY__ */
  916.  
  917.